home *** CD-ROM | disk | FTP | other *** search
/ The Games Room / The Games Room.iso / amiga / card_games / spades / source / input.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-04-02  |  11.9 KB  |  427 lines
  1. /*
  2.    FILE: Input.c
  3.    PURPOSE: Routines for getting user input.
  4.    AUTHOR: Gregory M. Stelmack
  5. */
  6.  
  7. #ifndef GLOBALS_H
  8. #include "Globals.h"
  9. #endif
  10.  
  11. extern struct Menu *SpadesMenu;
  12.  
  13. struct EasyStruct    AboutES =
  14. {
  15.    sizeof(struct EasyStruct),
  16.    0,
  17.    "About Spades 2.12",
  18.    "Spades 2.12 by:\nGregory M. Stelmack\n8723 Del Rey Ct. #11-A\nTampa, FL 33617",
  19.    "OK"
  20. };
  21.  
  22. /**********************************************************
  23. * Function: ReadMouse                                     *
  24. * Parameters: none                                        *
  25. * Return Values: none                                     *
  26. * Purpose: Wait for mouse input, and update the mouse     *
  27. *          variables accordingly.                         *
  28. **********************************************************/
  29. void ReadMouse()
  30. {
  31.    ULONG class,menunum,itemnum,subnum;
  32.    USHORT code,selection,flags;
  33.    BOOL gotmouse;
  34.    BOOL QuitFlag,NewFlag;
  35.    struct IntuiMessage  *Message;
  36.    
  37.    /* Loop until we have a mouse message */
  38.  
  39.    gotmouse = FALSE;
  40.    QuitFlag = FALSE;
  41.    NewFlag = FALSE;
  42.      
  43.    while(!gotmouse)
  44.    {
  45.       /* Wait for Intuition Message */
  46.       
  47.       Wait(1L<<Wdw->UserPort->mp_SigBit);    
  48.         while(Message=(struct IntuiMessage *) GetMsg(Wdw->UserPort))
  49.         {
  50.          /* Interpret Message */
  51.     
  52.          class = Message->Class;
  53.          code = Message->Code;
  54.          ReplyMsg((struct Message *)Message);
  55.  
  56.          switch(class)
  57.          {
  58.             case MENUPICK:
  59.                selection = code;
  60.                while (selection != MENUNULL)
  61.                {
  62.                   menunum = MENUNUM(selection);
  63.                   itemnum = ITEMNUM(selection);
  64.                   subnum  = SUBNUM(selection);
  65.                   flags = ((struct MenuItem *)ItemAddress(SpadesMenu,
  66.                            (LONG)selection))->Flags;
  67.                   switch(menunum)
  68.                   {
  69.                      case 0:     /* Project menu */
  70.                         switch(itemnum)
  71.                         {
  72.                            case 0:     /* New Game */
  73.                               NewFlag = TRUE;
  74.                               break;
  75.                            case 1:     /* Save Hand */
  76.                               if (flags&CHECKED)
  77.                                     SaveHand = TRUE;
  78.                               else
  79.                                     SaveHand = FALSE;
  80.                               break;
  81.                            case 2:     /* Print Hand */
  82.                               break;
  83.                            case 3:     /* About */
  84.                               (void)EasyRequest(Wdw,&AboutES,NULL,NULL);
  85.                               break;
  86.                            case 4:     /* Quit */
  87.                               QuitFlag = TRUE;
  88.                               break;
  89.                            default:
  90.                               break;
  91.                         }
  92.                         break;
  93.                      case 1:     /* Game menu */
  94.                         switch(itemnum)
  95.                         {
  96.                            case 0:     /* Bags */
  97.                               if (flags&CHECKED)
  98.                                     BagsRule = TRUE;
  99.                               else
  100.                                     BagsRule = FALSE;
  101.                               break;
  102.                            case 1:     /* Nil */
  103.                               if (flags&CHECKED)
  104.                                     NilRule = TRUE;
  105.                               else
  106.                                     NilRule = FALSE;
  107.                               break;
  108.                            case 2:     /* Suggest */
  109.                               Button = MRIGHT;
  110.                               gotmouse = TRUE;
  111.                               break;
  112.                            default:
  113.                               break;
  114.                         }
  115.                         break;
  116.                      default:
  117.                         break;
  118.                   }
  119.                   selection = ((struct MenuItem *)
  120.                               ItemAddress(SpadesMenu,(LONG)selection))
  121.                               ->NextSelect;
  122.                }
  123.                break;
  124.                
  125.                 case MOUSEBUTTONS:
  126.                switch(code)
  127.                {
  128.                   case SELECTUP:
  129.                      Button=MLEFT;
  130.                      gotmouse=TRUE;
  131.                      Mx=((SHORT) Message->MouseX);
  132.                      My=((SHORT) Message->MouseY);
  133.                      break;
  134.                   default:
  135.                      break;
  136.                }
  137.     
  138.             default:
  139.                break;
  140.                 
  141.          }  /* end switch */
  142.       }  /* end while message to process */
  143.         
  144.       if (QuitFlag == TRUE)
  145.       {
  146.          WrapUp();
  147.       }
  148.       else if (NewFlag == TRUE)
  149.       {
  150.          Spades();
  151.       }
  152.    }  /* end while not gotmouse */
  153. } 
  154.  
  155. /**********************************************************
  156. * Function: FinishRoutine                                 *
  157. * Parameters: none                                        *
  158. * Return Values: none                                     *
  159. * Purpose: Display final score, ask to play again.        *
  160. **********************************************************/
  161. void FinishRoutine()
  162. {
  163.    BOOL haveinput;
  164.  
  165.    SetRast(RP,BLUP);
  166.    SetAPen(RP,WHTP);
  167.    SetBPen(RP,BLUP);
  168.  
  169.    Move(RP,112,56);
  170.    Text(RP,"FINAL SCORE:",12);
  171.    Move(RP,80,72);
  172.    Text(RP,"YOU:",4);
  173.    Move(RP,184,72);
  174.    Text(RP,"ME:",3);
  175.    SetAPen(RP,YELP);
  176.    itoa(PlayerScore,String);
  177.    Move(RP,116,72);
  178.    Text(RP,String,strlen(String));
  179.    itoa(CompScore,String);
  180.    Move(RP,212,72);
  181.    Text(RP,String,strlen(String));
  182.    
  183.    Move(RP,112,96);
  184.    Text(RP,"PLAY AGAIN ?",12);
  185.    SetAPen(RP,BLKP);
  186.    SetBPen(RP,WHTP);
  187.    Move(RP,112,112);
  188.    Text(RP,"YES",3);
  189.    Move(RP,188,112);
  190.    Text(RP,"NO",2);
  191.    
  192.    haveinput=FALSE;
  193.    while (!haveinput)
  194.    {
  195.       ReadMouse();
  196.       
  197.       /* Check for YES clicked */
  198.       
  199.       if ((Mx>111)&&(Mx<136)&&(My>105)&&(My<114))
  200.          haveinput=TRUE;
  201.          
  202.       /* Check for NO clicked */
  203.       
  204.       if ((Mx>187)&&(Mx<204)&&(My>105)&&(My<114))
  205.          WrapUp();
  206.    }
  207. }
  208.  
  209. /**********************************************************
  210. * Function: GetPlayerCard                                 *
  211. * Parameters: none                                        *
  212. * Return Values: card picked to play                      *
  213. * Purpose: Allow player to pick card to play.             *
  214. **********************************************************/
  215. int GetPlayerCard()
  216. {
  217.    int i,x,card;
  218.   
  219.    /* Let player know that it's his/her turn */
  220.   
  221.    SetBPen(RP,BLUP);
  222.    SetAPen(RP,YELP);
  223.    Move(RP,200,150);
  224.    Text(RP,"PLAY A CARD",11);
  225.   
  226.    /* Loop until we get a good card */
  227.   
  228.    FOREVER
  229.    {
  230.       ReadMouse();                        /* Wait for mouse click */ 
  231.       if (Button==MRIGHT) SuggestCard();  /* Player wants a suggestion */
  232.       if (Button==MLEFT)                  /* Did player pick a card ? */
  233.       {
  234.          for (i=12 ; i>=0 ; i--)          /* Check from right to left */
  235.          {
  236.             x=(i*10)+21;                  /* Set left corner for card */
  237.         
  238.             /* See if clicked inside this card and if card is
  239.                still unplayed */
  240.         
  241.             if ((My<187)&&(My>144)&&(Mx<(x+42))&&(Mx>=x)&&(Hand[0][i]))
  242.             {
  243.                if (ValidCard(i))  /* Was this a playable card ? */
  244.                {
  245.                   card=Hand[0][i]-1;
  246.                   Hand[0][i]=0;   /* Mark card as played */
  247.                   
  248.                   /* Check to see if Spades were broken */
  249.                   
  250.                   if ((card/13)==SPADES) SpadePlayed=TRUE;
  251.             
  252.                   /* Erase suggestion '*' */
  253.             
  254.                   SetAPen(RP,BLUP);
  255.                   SetOPen(RP,BLUP);
  256.                   RectFill(RP,21,136,170,144);
  257.             
  258.                   DrawCard(CardX[0],CardY[0],card); /* Draw played card */
  259.             
  260.                   /* Erase prompt message */
  261.             
  262.                   SetBPen(RP,BLUP);
  263.                   Move(RP,200,150);
  264.                   Text(RP,"           ",11);
  265.             
  266.                   /* Send back played card */
  267.             
  268.                   return(card);
  269.                }
  270.                else     /* chosen card was not valid, need a new card */
  271.                      i=-1;
  272.             }
  273.          }
  274.       }
  275.    }
  276. }
  277.  
  278. /**********************************************************
  279. * Function: ValidCard                                     *
  280. * Parameters: card -- card in player's hand to check      *
  281. * Return Values: was card valid or not?                   *
  282. * Purpose: To determine if the card chosen by the player  *
  283. *   was valid or not.                                     *
  284. **********************************************************/
  285. BOOL ValidCard(card)
  286. int card;
  287. {
  288.    int i,suit,leadsuit;
  289.   
  290.    SuitNumber[DIAMONDS]=0;
  291.    SuitNumber[CLUBS]   =0;
  292.    SuitNumber[HEARTS]  =0;
  293.    SuitNumber[SPADES]  =0;
  294.   
  295.    /* Count number of cards player has in each suit */
  296.   
  297.    for (i=0 ; i<13 ; i++)
  298.    {
  299.       if (Hand[0][i]) SuitNumber[(Hand[0][i]-1)/13]++;
  300.    }
  301.   
  302.    suit=(Hand[0][card]-1)/13; /* Find suit of played card */
  303.   
  304.    if (!TrickLead)            /* Player is leading */
  305.    {
  306.       /* If he didn't lead a spade, it was a good play */
  307.       if (suit!=SPADES) return(TRUE);
  308.     
  309.       /* If he only has spades, he has no choice */ 
  310.       if ((!SuitNumber[0])&&(!SuitNumber[1])&&(!SuitNumber[2]))
  311.             return(TRUE);
  312.     
  313.       /* If spades have been played, he can lead anything */
  314.       if (SpadePlayed) return(TRUE);
  315.     
  316.       /* Must have lead a spade when it was illegal to */
  317.       return(FALSE);
  318.    }
  319.   
  320.    /* Player doesn't lead */
  321.   
  322.    leadsuit=Card[TrickLead]/13;       /* Find suit that was lead */
  323.   
  324.    /* If he played the suit that was lead, he is OK */
  325.    if (suit==leadsuit) return(TRUE);
  326.   
  327.    /* If he didn't have any, he's OK */
  328.    if (!SuitNumber[leadsuit]) return(TRUE);
  329.   
  330.    /* Must have had some but didn't play them */
  331.    return(FALSE);
  332. }
  333.  
  334. /**********************************************************
  335. * Function: GetPlayerBid                                  *
  336. * Parameters: none                                        *
  337. * Return Values: bid -- number of tricks bid              *
  338. * Purpose: Get the human player's bid. Could use gadgets, *
  339. *          but this is easier to program.                 *
  340. **********************************************************/
  341. int GetPlayerBid()
  342. {
  343.    int bid=1,length;
  344.    BOOL havebid=FALSE;
  345.  
  346.    ShowHand();
  347.  
  348.    /* Draw input box */
  349.   
  350.    SetAPen(RP,YELP);
  351.    SetBPen(RP,BLKP);
  352.    Move(RP,258,142);
  353.    Text(RP,"BID",3);
  354.    Move(RP,250,150);
  355.    Text(RP,"  +  ",5);
  356.    Move(RP,250,158);
  357.    Text(RP,"   OK",5);
  358.    Move(RP,250,166);
  359.    Text(RP,"  -  ",5);
  360.   
  361.    /* Loop until OK is clicked */
  362.   
  363.    while(!havebid)
  364.    { 
  365.       /* Draw Current Bid */
  366.     
  367.       SetAPen(RP,GRNP);
  368.       SetBPen(RP,BLKP);
  369.       Move(RP,250,158);
  370.       Text(RP,"  ",2);
  371.       itoa(bid,String);
  372.       length=strlen(String);
  373.       Move(RP,(258-(4*length)),158);
  374.       Text(RP,String,length);
  375.     
  376.       /* Wait for Mouse input */
  377.     
  378.       ReadMouse();
  379.       if (Button==MLEFT)   /* Left Button Pressed */
  380.       {
  381.          /* plus sign clicked */
  382.          if ((Mx>265)&&(Mx<274)&&(My>143)&&(My<152)) bid++;
  383.             
  384.          /* OK clicked */
  385.          if ((Mx>273)&&(Mx<290)&&(My>151)&&(My<160)) havebid=TRUE;
  386.          
  387.          /* minus sign clicked */
  388.          if ((Mx>265)&&(Mx<274)&&(My>159)&&(My<168)) bid--;
  389.       }
  390.       if (Button==MRIGHT)  /* Right Button Pressed */
  391.       {
  392.          bid=CalcBid(0);   /* Suggest a Bid */
  393.       }
  394.     
  395.       /* Make sure bid is valid */
  396.     
  397.       if (NilRule)
  398.       {
  399.          if (bid<0) bid=0;
  400.          if (bid>13) bid=13;
  401.       }
  402.       else
  403.       {
  404.          if (bid<1) bid=1;
  405.          if (bid>12) bid=12;
  406.       }
  407.    }
  408.   
  409.    /* Erase Input Box */
  410.   
  411.    SetAPen(RP,BLUP);
  412.    SetOPen(RP,BLUP);
  413.    RectFill(RP,250,135,291,168);
  414.   
  415.    /* Display the bid */
  416.   
  417.    SetAPen(RP,YELP);
  418.    SetBPen(RP,BLUP);
  419.    itoa(bid,String);
  420.    Move(RP,MsgX[0],MsgY[0]);
  421.    Text(RP,String,strlen(String));
  422.   
  423.    /* Send the bid back */
  424.   
  425.    return(bid);
  426. }
  427.